package scales.xml.impl
import javax.xml.parsers._
import javax.xml.stream._
import javax.xml.validation._
import javax.xml.transform._
import org.xml.sax.XMLReader
import org.xml.sax.helpers.XMLReaderFactory
import scales.utils.resources._
import scales.xml.parser.sax._
import scales.xml.trax.ScalesSource
import scales.xml.asStreamSource
trait XmlFactories {
def newSchema( source : Source, factory : Loaner[SchemaFactory] = DefaultXSDSchemaFactoryPool ) =
factory.loan{
f =>
import javax.xml.transform.stream._
import scales.xml.ScalesXml._
if (!Versions.newSchemaShouldSerialize)
f.newSchema(source)
else
if (source.isInstanceOf[ScalesSource]) {
val s = source.asInstanceOf[ScalesSource]
f.newSchema(asStreamSource((s.stream, s.documentLike)))
} else f.newSchema(source)
}
}
object DefaultSAXParserFactoryPool extends SimpleUnboundedPool[SAXParserFactory] { pool =>
def create = {
val parserFactory = SAXParserFactory.newInstance()
parserFactory.setNamespaceAware(true)
parserFactory.setFeature("http://xml.org/sax/features/namespaces", true)
parserFactory.setValidating(false)
parserFactory
}
val parsers = new Loaner[SAXParser] with DefaultSaxSupport {
def loan[X]( tThunk : SAXParser => X ) : X =
pool.loan{ x => tThunk(x.newSAXParser) }
}
}
object NoVersionSAXParserFactoryPool extends SimpleUnboundedPool[SAXParserFactory] { pool =>
def create = {
val parserFactory = SAXParserFactory.newInstance()
parserFactory.setNamespaceAware(true)
parserFactory.setFeature("http://xml.org/sax/features/namespaces", true)
parserFactory.setValidating(false)
parserFactory
}
val parsers = new Loaner[SAXParser] with DefaultSaxSupport {
override def getXmlVersion( reader : XMLReader ) : AnyRef =
null
def loan[X]( tThunk : SAXParser => X ) : X =
pool.loan{ x => tThunk(x.newSAXParser) }
}
}
object DefaultXMLReaderFactoryPool extends SimpleUnboundedPool[XMLReader] with DefaultSaxSupport { pool =>
def create =
XMLReaderFactory.createXMLReader()
}
object NoVersionXmlReaderFactoryPool extends SimpleUnboundedPool[XMLReader] with DefaultSaxSupport {
override def getXmlVersion( reader : XMLReader ) : AnyRef =
null
def create =
XMLReaderFactory.createXMLReader()
}
object DefaultDOMFactoryPool extends SimpleUnboundedPool[DocumentBuilderFactory] { pool =>
def create = {
val dbFactory = DocumentBuilderFactory.newInstance()
dbFactory.setNamespaceAware(true)
dbFactory.setValidating(false)
dbFactory
}
val parsers = new Loaner[DocumentBuilder] {
def loan[X]( tThunk : DocumentBuilder => X ) : X =
pool.loan{ x => tThunk(x.newDocumentBuilder) }
}
}
object DefaultStaxInputFactoryPool extends SimpleUnboundedPool[XMLInputFactory] { pool =>
val cdata = "http://java.sun.com/xml/stream/properties/report-cdata-event"
def create = {
val fac = XMLInputFactory.newInstance()
if (fac.isPropertySupported(cdata)) {
fac.setProperty(cdata, java.lang.Boolean.TRUE);
}
fac
}
}
object DefaultXSDSchemaFactoryPool extends SimpleUnboundedPool[SchemaFactory] { pool =>
def create = {
val fac = SchemaFactory.newInstance(javax.xml.XMLConstants.W3C_XML_SCHEMA_NS_URI)
fac
}
}
object Versions {
lazy val traxSourceShouldSerialize = {
val p = System.getProperty("scales.traxSourceShouldSerialize")
if (p ne null)
p.toBoolean
else {
import javax.xml.transform._
val t = TransformerFactory.newInstance.newTransformer
val cn = t.getClass.getName
cn == "org.apache.xalan.transformer.TransformerIdentityImpl"
}
}
lazy val newSchemaShouldSerialize = {
val p = System.getProperty("scales.newSchemaShouldSerialize")
if (p ne null)
p.toBoolean
else {
val fac = SchemaFactory.newInstance(javax.xml.XMLConstants.W3C_XML_SCHEMA_NS_URI)
val pack = fac.getClass.getPackage
val ver = pack.getImplementationVersion
if (ver eq null)
false
else {
val pre = ver.substring(0,3)
if (pre == "1.5" || pre == "1.6")
true
else
false
}
}
}
}